#include <QuinielaConfiguration.h>

QuinielaConfiguration::QuinielaConfiguration() : GameConfiguration()
{
	// inicalizar todas la variables de clase
	m_IsEnabled = false;
	m_PathImageButton = "";
	m_PathAppDllName = "";
	m_CodigoAgente = 0;
	m_NombreAgente = "";
	m_DireccionAgente = "";
	m_LocalidadAgente = "";
	m_NumeroTerminal = 0;
	m_NumeroTarjeta = 0;
	m_NroSecuencia = 0;
	m_TipoTerminal = 0x20;
	m_NumTerminalAgencia = 0x20;
	m_Version = 0x20;
	m_SubVersion = 0x20;
}


QuinielaConfiguration::~QuinielaConfiguration()
{
}

void QuinielaConfiguration::deserialize( QByteArray data )
{
	BMMemoryUtils memUtil;
	unsigned int bytesCopied = 0;
	
	data.remove( 0 , 6);
	data.remove( data.size() - 3 , 3);

	unsigned char * buff = (unsigned char *) malloc( data.size() );
	memset( buff , '\0' , data.size() );

	for (short i = 0; i < data.size() ; i++ )
		buff[i] = data.at(i);

	// id de mensaje de respuesta de pedido de sorteo (0x51)
	memUtil.MemoryCopy( &m_IdMessage , buff , sizeof( m_IdMessage ) );
	bytesCopied += sizeof( m_IdMessage );

	// Transaccion (0xd1)
	memUtil.MemoryCopy( &m_Transaccion , buff + bytesCopied, sizeof( m_Transaccion) );
	bytesCopied += sizeof( m_Transaccion );

	// codigo de error
	memUtil.MemoryCopy( &m_ErrorCode , buff + bytesCopied , sizeof( m_ErrorCode ) );
	bytesCopied += sizeof( m_ErrorCode );

	// Controlo si hay error
	if ( m_ErrorCode == 0 )
	{
		// id de transaccion
		memUtil.MemoryCopy( &m_IdTransaction , buff + bytesCopied , SIZE_ID_TRANSACTION , BIG_ENDIAN );
		bytesCopied += SIZE_ID_TRANSACTION;

		// dia
		memUtil.MemoryCopy( &m_Dia , buff + bytesCopied , sizeof( m_Dia ) ); 
		bytesCopied += sizeof( m_Dia );
	
		// mes
		memUtil.MemoryCopy( &m_Mes , buff + bytesCopied , sizeof( m_Mes ) ); 
		bytesCopied += sizeof( m_Mes );

		// anio
		memUtil.MemoryCopy( &m_Anio , buff + bytesCopied , sizeof( m_Anio ) ); 
		bytesCopied += sizeof( m_Anio );

		// hora
		memUtil.MemoryCopy( &m_Hora , buff + bytesCopied , sizeof( m_Hora ) ); 
		bytesCopied += sizeof( m_Hora );

		// minutos
		memUtil.MemoryCopy( &m_Minutos , buff + bytesCopied, sizeof( m_Minutos ) ); 
		bytesCopied += sizeof( m_Minutos );

		// segundos
		memUtil.MemoryCopy( &m_Segundos , buff + bytesCopied, sizeof( m_Segundos ) ); 
		bytesCopied += sizeof( m_Segundos );
	
		// cantidad de entes
		memUtil.MemoryCopy( &m_CantEntes , buff + bytesCopied , sizeof( m_CantEntes ) ); 
		bytesCopied += sizeof( m_CantEntes );

		// importe maximo de la apuesta
		memUtil.MemoryCopy( &m_ImpMaxAp , buff + bytesCopied , sizeof( m_ImpMaxAp ) ); 
		bytesCopied += sizeof( m_ImpMaxAp );

		// Importe minimo de la apuesta
		memUtil.MemoryCopy( &m_ImpMinAp , buff + bytesCopied , sizeof( m_ImpMinAp ) ); 
		bytesCopied += sizeof( m_ImpMinAp );

		// Importe maximo del ticket
		memUtil.MemoryCopy( &m_ImpMaxTick , buff + bytesCopied , sizeof( m_ImpMaxTick ) ); 
		bytesCopied += sizeof( m_ImpMaxTick );
	
		// Importe minimo del ticket
		memUtil.MemoryCopy( &m_ImpMinTick , buff + bytesCopied , sizeof( m_ImpMinTick ) ); 
		bytesCopied += sizeof( m_ImpMinTick );

		// Incremento
		memUtil.MemoryCopy( &m_Incremento , buff + bytesCopied , sizeof( m_Incremento ) ); 
		bytesCopied += sizeof( m_Incremento );

		// Cantidad maxima de apuestas
		memUtil.MemoryCopy( &m_CantMaxAps , buff + bytesCopied , sizeof( m_CantMaxAps ) ); 
		bytesCopied += sizeof( m_CantMaxAps );

		// Lista de descripciones de entes
		char descripcion[LENGTH_ENTES + 1];
		unsigned char bitmap = MAX_ENTE_BITMAP;
		for ( short int i = 1 ; i <= m_CantEntes ; i++ )
		{
			memset( descripcion , '\0' , LENGTH_ENTES + 1 );
			memUtil.MemoryCopy( &descripcion , buff + bytesCopied , LENGTH_ENTES , BIG_ENDIAN );
			bytesCopied += LENGTH_ENTES;
			m_EntesDescMap.insert( i , QString( descripcion ) );
		
			// Establezco el bitmap de entes
			m_EntesBitmapsMap.insert( i , bitmap );
			bitmap = bitmap / 2; // enciende el bit anterior, pasara de 00010000 (0x10) a 00001000 (0x08), 00000100 (0x04), 00000010 (0x02) y 00000001 (0x01)
		}

		// Comienzo a procesar los sorteos
		short int bytesRestantes = data.size() - bytesCopied;
		short int index = 0;
		while ( bytesRestantes > 0 )
		{
			char fixedBuffSorteo[FIXED_SIZE_SORTEO];
			memUtil.MemoryCopy( fixedBuffSorteo , buff + bytesCopied , FIXED_SIZE_SORTEO , BIG_ENDIAN );
			bytesCopied += FIXED_SIZE_SORTEO;
		
			// copio el sorteo en un QByteArray
			QByteArray dataSorteo = "";
			for ( short i = 0 ; i < FIXED_SIZE_SORTEO ; i++ )
				dataSorteo.append( fixedBuffSorteo[i] );
		
			// obtengo la cantidad de lineas adicionales
			unsigned char cantLineasAdd = fixedBuffSorteo[ FIXED_SIZE_SORTEO - 1];

			// Agrego las lineas adicionas necesarias
			for ( short int j = 0 ; j < cantLineasAdd ; j++ )
			{
				char fixedBuffLineaAdd[ FIXED_SIZE_LINEA_ADD ];
				memUtil.MemoryCopy( fixedBuffLineaAdd , buff + bytesCopied , FIXED_SIZE_LINEA_ADD , BIG_ENDIAN );
				bytesCopied += FIXED_SIZE_LINEA_ADD;

				// copio la linea adicional a un QByteArray
				QByteArray lineaAdd = "";
				for (short int k = 0 ; k < FIXED_SIZE_LINEA_ADD ; k++ )
					lineaAdd.append( fixedBuffLineaAdd[k] );

				dataSorteo.append( lineaAdd );
			}

			// creo la configuracion del sorteo
			SorteoConfiguration * sorteoConf = new SorteoConfiguration();
			sorteoConf->deserialize( dataSorteo );
		
			// inserto el sorteos en el map
			m_SorteosMap.insert( sorteoConf->m_NroSorteo , sorteoConf );
			index++;

			// actualizo bytesRestantes
			bytesRestantes = data.size() - bytesCopied;
		}

		// TODO:  bytesRestantes == 0 ? Tudo bon tudo legal : Tudo mal, tirar exception!!
	}
	else
	{
		// obtengo decripcion del error
		char descripcion[512];
		memset( descripcion , '\0' , 512 );
		memUtil.MemoryCopy( descripcion , buff + bytesCopied , data.size() - bytesCopied , BIG_ENDIAN );
		bytesCopied += data.size() - bytesCopied;
		m_ErrorDescription = descripcion;
	}

	free(buff);
}

void QuinielaConfiguration::save()
{
}

void QuinielaConfiguration::update( QByteArray data )
{
}